CD ROM Paradise Collection 4/CD ROM Paradise Collection 4 1995 Nov.iso/win/golfiery.zip/READ.ME

Text File | 1995-04-03 | 31KB | 776 lines

READ.ME
=======

The DLL in this archive (GOLFIERY.DLL) implements functions for tooltip-like
windows and balloon help. Golfiery and its demos and demo-sources are
freeware. Golfiery is copyrighted software, but you're free to distribute
it with your applications. Read the "about the use of this software" section
for more details.

If this text file looks odd, don't worry. I'm also working on a Windows help
file with a Golfiery API reference. Till that time you have to do it with
the source code of the demos and this read.me file.

Don't mind my English too.

There are several sections/paragraphs in this text file:

- What's balloon help
- GOLFIERY.DLL & files
- demos
- description of the Golfiery functions
- shortcomings
- about the author
- about the use of this software


What's balloon help
===================

I don't hope "balloon help" is trademarked. "ToolTips" _is_. Golfiery provides
several functions for creating tooltip and balloonhelp windows.
In Golfiery's lingo tooltips are FlyByHints. FlyByHints give a brief
description (hint) of a button's (or any other screen part's) purpose. They're
a much handier than hint texts in statusbars. FlyByHints float above or
somewhere in the neighbourhood of a screen part.

BalloonHelp is another useful help window. I believe the MacOS had these things
first (correct me if I'm wrong). The term BalloonHelp refers to the balloons
in comics. Comic characters "talk" with balloons. In GUI environments, balloons
have the same purpose: they let screen parts of your applications talk.

As opposed to tooltips, BalloonHelp windows often have a title and a
multi-line text. A balloon often points at the screen part that needs be
explained. FlyByHints and Balloons also differ in behaviour: FlyByHints
provide "hints", Balloons "explain"; FlyByHints are what I call
volatile: they appear for a short time on-screen, if you move out of the
area of the hinted screen part, the FlyByHint should "disappear". A balloon
disappears whenever the user performs a keyboard or mouse action (typing or
clicking).


GOLFIERY.DLL & files
====================

The Golfiery DLL provides about ten functions. Four of these functions are
for ToolTips (FlyByHints), the other functions are for BalloonHelp. The DLL
is rather small so it won't take up a lot of your hard drive's space. The
DLL should be installed in the Windows system directory.

There are several files within the golfiery package, the most important are:

GOLFIERY.DLL  - The golfiery DLL
GOLFIERY.H    - Golfiery include file for C/C++
GOLFIERY.LIB  - Import library. You can create your own import lib by
                using implib.exe on GOLFIERY.DLL (implib.exe is supplied
                by all Windows C/C++ compiler vendors)
GOLFIERY.BAS  - Basic file with definitions
READ.ME       - this file


Demos
=====

Currently this archive contains three programming examples:

- tooltips.exe + sources. Demonstrates how to use the FlyByHint functions
in a regular C program.
- balloon.exe + sources. Demonstrates some balloon help functions. In C.
- balloonh.bas and balloonh.frm. A Visual basic demo. You won't find
a compiled example, only sources. The Visual Basic demo has been written
by Erik Baas and demonstrates how to use some of the FlyByHint functions,
and the special VB functions of Golfiery.

Both C samples show how to superclass the flyby hint and balloonhelp classes.
If you have a Golfiery demo written in any other language, please feel free
to submit the source code and/or necessary headers. Especially code samples
for Delphi are welcome. I've done a lot programming wit Pascal OWL, but
Delphi is far too difficult for me.


Description of the GOLFIERY functions
=====================================

FlyByHints/ToolTips
-------------------

The FlyByHints are the most "difficult" windows to program *with*. Remember:
the FlyByHints are displayed whenever the mouse cursor is above a screen part
that needs to be hinted. In plain programmer's words: your programming
environment should allow you to trap MouseMove events. So insert a call to
a flyby hint function in your WM_MOUSEMOVE code. The FlyByHint windows
auto-destruct themselves, you don't have to do anything else (Golfiery handles
a lot for you). There's one thing the FlyByHint functions can't do: detect
that a flyby hint must appear when the user has not touched the keyboard for
a while and the mouse cursor hasn't been moved. Luckily most application
frameworks have a special function that is called whenever an application
is idle (doing nothing). Perhaps you should insert a call to FlyByHint inside
this idle function too. (Visual Basic programmers could use a timer and the
Win API function GetCursorPos. If the mouse hasn't moved for a while the
timer function could decide to call a FlyByHint function)

In all other cases FlyByHint is fairly intelligent. I call the FlyByHint
asynchroneously: it can be called many times (esp. within a mouse move
event), but a flyby hint will only appear if certain conditions are met
(no other flyby hint on-screen, mousemove message generated by an
inactive window etc). The advantage of this approach is that you supply the
parameters and Golfiery decides whether the conditions are met.


The FlyByHint functions
-----------------------

-+++- FlyByHint -+++-

BOOL WINAPI FlyByHint (HWND hwndFrame, LPRECT rcRect, LPCSTR szHintText);
Declare Sub FlyByHint Lib "golfiery.dll" (ByVal hwndFrame%, rcRect As Rect, ByVal szHintText$)

Parameters

hwndFrame - The FlyByHint behaves like a popup window, like a little dialog.
  Imagine the hwndFrame as the window that deactivates when a normal
  modeless dialog is about to be displayed. Mostly the hwndFrame is the
  parent of the FlyByHint, but there are some exceptions.
  When the flyby hint is used within a MDI parent's toolbar, then the
  MDI parent form/window is the hwndFrame. When FlyByHint is used within
  an MDI child form/window, then the MDI parent form/window is the
  hwndFrame too (because the MDI *parent* becomes inactive). However when the
  FlyByHint is used within a modal dialog, the *modal dialog* is the hwndFrame.

  The hwndFrame parameter should be compared with the hParent parameter in
  the MessageBox API function. There's only one exception: hwndFrame _can't_
  be the desktop window.

rcRect - is a pointer to the rectangular area (in screen coordinates) for which
  a FlyByHint should appear. When a FlyByHint should appear for a window the
  FlyByHintFromWindow function is the obvious choice. However, mostly tool
  bar buttons are not windows at all, instead they're drawn by some tool bar
  parent window. If this is the case calculate the area yourself using the
  Windows API function GetWindowRect and the RECT structure. For Visual Basic
  programmers: this function and RECT are defined in GOLFIERY.BAS.

szHintText - The hint text that should appear in the flyby hint.


Result

Actually all Golfiery functions return the HWND of the created window. When the
function returns and a Golfiery window (tooltip or balloon) has been created ,
the window associated with the HWND might be destroyed. So the result value
could be used as "success test", but it doesn't do any harm if you neglect
the return value.


Basic example

Sub Form_MouseMove (Button As Integer, Shift As Integer, X As Single, Y As Single)
  ' For controls without a hWnd property or MouseMove event:
  Dim P As Rect, PA As PointApi, r%

  PA.X = X
  PA.Y = Y

  ' Windows API function
  ClientToScreen hWnd, PA

  ' Function in BALLOONH.BAS
  GetControlRect Shape1, P
  If PA.X >= P.Left And PA.X < P.Right And PA.Y >= P.Top And PA.Y < P.Bottom Then
    VBFlyByHint Form1.hWnd, Shape1, "VBFlyByHint: Shape1"
  End If
End Sub


C example

/*** rcManagedArea is the RECT of an area painted by hDlg ***/
case WM_MOUSEMOVE:
  if (_fToolTip)
    if (PtInRect(&rcManagedArea, *((LPPOINT)&lParam))) {
      RECT  rcWindow;

      rcWindow = rcManagedArea;
      /*** Convert it from client area to screen coordinates ***/
      MapWindowPoints(hDlg, 0, (LPPOINT)&rcWindow, 2);
      FlyByHint (_hwndMain, &rcWindow, painttext);
    }
    break;
-+++-           -+++-

-+++- FlyByHintFromWindow -+++-

BOOL WINAPI FlyByHintFromWindow (HWND hwndFrame, HWND hwndHintAbout, LPCSTR szString);
Declare Sub FlyByHintFromWindow Lib "golfiery.dll" (ByVal hwndFrame%, ByVal hwndHintAbout%, ByVal szString$)

Parameters

hwndFrame - The notorious frame window handle. See FlyByHint for a description.
hwndHintAbout - The window handle of the window that needs to be described by
  a flyby hint
szString - The hint text


Basic example

Sub Command1_MouseMove (Button As Integer, Shift As Integer, X As Single, Y As Single)
  ' For Controls with a hWnd property:
  FlyByHintFromWindow Form1.hWnd, Command1.hWnd, "Command button 1"
End Sub


C example

if (uMsg == WM_MOUSEMOVE)
  if (_fToolTip) {
    LoadString(_hInst, IDS_TEXT_HELP + id, (LPSTR)&buf, sizeof buf);
    FlyByHintFromWindow(_hwndMain, hChild, buf);
  }
-+++-                     -+++-

-+++- FlyByHintFromClass -+++-

BOOL WINAPI FlyByHintFromClass (HINSTANCE hInst, LPCSTR lpszClassName, HWND hwndFrame, LPRECT rcRect, LPCSTR szString);

Parameters

hInst - The program instance that defined a new FlyByHint class
lpszClassName - The name of the new class. The old class' name is defined as
  #define FLYBYHINTCLASSNAME "Ahii_FlyByToolTip"
hwndFrame - see FlyByHint
rcRect - same as in FlyByHint. The area that needs to be hinted.
szString - The hint text


Description

This function can only be used by programming languages that allow superclassing.
Superclassing is a Windows programming technique that allows the programmer
to build upon predefined Windows classes. If Golfiery has been loaded, the
FlyByHint is a predefined class too. If you want to know how superclassing
works in C, refer to the tooltips.c demo file. Superclassing is also possible
with C++ Frameworks (MFC and OWL do superclassing behind the scenes).

There are several messages that should always be passed to old class' procedure:

WM_CREATE
WM_DESTROY
WM_ERASEBKGND - Returns 1 indicating the FlyByHint class erased background
WM_PAINT - By default the WM_PAINT handling code queries the used font
  by sending WM_GETFONT and WM_CTLCOLOR messages.

These messages may be intercepted by your class:

WM_GETFONT - By default the FlyByHint class returns the Ansi variable pitch
  system font. You could return a handle of a different (previously created)
  font. Golfiery doesn't destroy fonts that it doesn't own. If you allocated
  a font for your superclass, you're responsible for destroying the font
  (this makes sense in GUI programming).

WM_CTLCOLOR - If HIWORD(lParam) == CTLCOLOR_DLG the FlyByHint class returns
  the class background brush. This brush is used in the WM_PAINT code. If you
  want to change the back ground brush, return a different handle or change
  your superclass' brush. This message is also ideal for changing the
  color of text. The wParam contains the handle of the device context used
  by the WM_PAINT code. (Read the SDK for more info about WM_CTLCOLOR).

Read the "Superclassing the BalloonHelp" section for more info on superclassing.
-+++-                    -+++-

-+++- VBFlyByHint -+++-

Declare Sub VBFlyByHint Lib "golfiery.dll" (ByVal hwndFrame%, VBObject As Any, ByVal szString$)

Parameters

hwndFrame% - See FlyByHint.
VBObject - The name of the Visual Basic object that will be hinted.
szString$ - The hint text


Description

This function is for Visual Basic programmers only. VBObject is the Control
name of a Visual Basic control.

This function will *probably* fail if you are using Visual basic version 1.
Visual Basic programmers should use this function whenever possible.
-+++-             -+++-


The BalloonHelp functions
-------------------------

The balloon help functions are far more easier to use. You don't need to
handle these function within an event handler. Just call them.

There are two special functions for Visual Basic.

-+++- BalloonHelp -+++-

BOOL WINAPI BalloonHelp (HWND hwndFrame, LPRECT rcArea, LPCSTR szTitle, LPCSTR szText);
Declare Sub BalloonHelp Lib "golfiery.dll" (ByVal hwndFrame%, rcArea As Rect, ByVal szTitle$, ByVal szText$)

Parameters

hwndFrame - The frame window that becomes inactive. See the description of
  FlyByHint.
rcArea - The (window) area that needs to be explained by a balloon help text
szTitle - The title of the balloon help window. By default bold face ANSI
  variable pitched system font. Might be NULL or empty.
szText - The help text. By default it appears in a the ANSI variable pitched
  system font. Might be NULL or empty.
-+++-             -+++-

-+++- BalloonHelpEx -+++-

BOOL WINAPI BalloonHelpEx (HWND hwndFrame, LPRECT rcArea, LPCSTR szTitle, LPCSTR szText, WORD wStyle);
Declare Sub BalloonHelpEx Lib "golfiery.dll" (ByVal hwndFrame%, rcArea As Rect, ByVal szTitle$, ByVal szText$, ByVal wStyle%)

Parameters

All parameters are the same as in BalloonHelp.
wStyle - A style for the BalloonHelp window.


Description

BalloonHelpEx is the extended version of BalloonHelp. Use the wStyle
parameter to "modify" the appearance of a balloon help window.
If you want to use more than one style use the "OR"-operator (in C: |, in
Basic: or, in Pascal: or) to combine them. Refer to balloon.c and
balloon.exe for a demonstration of the BalloonHelp styles.

BLNS_DEFAULT (0) - The default window style. The balloon has a tag and will
  position itself.

BLNS_LEFTTOP (1),
BLNS_RIGHTTOP (2),
BLNS_RIGHTBOTTOM (3),
BLNS_LEFTBOTTOM (4) - Use one of this styles to specify the position of
  the balloon tag (pointer)

BLNS_THINBORDER (0x10, &H10) - Draws a thin border around the balloon (instead
  of a thick anti-alias-like border)

BLNS_BALLOONATPOINT (0x20, &H20) - Places the balloontag position at the
  rcArea.left and rcArea.top position. The rcArea.right and rcArea.bottom
  fields are ignored. Can be combined with one of the tag position styles.
  If the tag position style is BLNS_DEFAULT, the tag position will be
  calculated by the balloon window.

BLNS_NOTAG (0x40, &H40) - Does not draw the tag/pointer of the balloon. It's
  still possible to position the balloon with BLNS_BALLOONATPOINT and one of
  the tag position styles. With this style on the tag is virtualized ;-).

Visual Basic programmers should look at the VBBalloonHelpEx function.


C example

  case WM_LBUTTONDOWN:
    RECT rcWindow;

    GetWindowRect(hWnd, &rcWindow);
    BalloonHelpEx(hWndFrame, &rcWindow, "Title", "This is the balloon text",
      BLNS_DEFAULT | BLNS_NOTAG | BLNS_THINBORDER);
    break;

or another example, with BLNS_BALLOONATPOINT:

  case WM_LBUTTONDOWN:
    RECT rcWindow;

    /*** Could use the lParam :-). Get the current cursor position ***/
    GetCursorPos((LPPOINT)&rcWindow);

    /*** Use a tag at the right bottom corner of the balloon ***/
    BalloonHelpEx(hWndFrame, &rcWindow, "Some Title", "This is a text",
      BLNS_RIGHTBOTTOM | BLNS_BALLOONATPOINT);
    break;
-+++-               -+++-

-+++- BalloonHelpFromWindow -+++-

BOOL WINAPI BalloonHelpFromWindow (HWND hwndFrame, HWND hwndInfoAbout, LPCSTR szTitle, LPCSTR szText);
Declare Sub BalloonHelpFromWindow Lib "golfiery.dll" (ByVal hwndFrame%, ByVal hWndInfoAbout%, ByVal szTitle$, ByVal szText$)


Parameters

hwndFrame, szTitle, szText - see BalloonHelp
hwndInfoAbout - The handle of the window that needs to be BalloonHelp-ed.


C example

  case WM_LBUTTONDOWN:
    BalloonHelpFromWindow(hwndFrame, hWndThisWindow, "Title", "This is a text");
    break;
-+++-                       -+++-

-+++- VBBalloonHelp -+++-

Declare Sub VBBalloonHelp Lib "golfiery.dll" (ByVal hwndFrame%, VBObject As Any, ByVal szTitle$, ByVal szText$)

This is a special function for VB programmers. All the parameters (except for
VBObject) are the same as for BalloonHelp. VBObject is the name of the
Visual Basic control that needs balloonhelp.
-+++-               -+++-

-+++- VBBalloonHelpEx -+++-

Declare Sub VBBalloonHelpEx Lib "golfiery.dll" (ByVal hwndFrame%, VBObject As Any, ByVal szTitle$, ByVal szText$, ByVal wStyle%)

Except for the VBObject parameter all parameters are the same as in
BalloonHelpEx. VBObject is the control name of a Visual Basic control.
-+++-                 -+++-


-+++- BalloonHelpFromClass -+++-

BOOL WINAPI BalloonHelpFromClass (HINSTANCE hInst, LPCSTR lpszClassName, HWND hwndFrame, LPRECT lprcArea, LPCSTR lpszTitle, LPCSTR lpszText, WORD wStyle);


Parameters

hInst - The instance handle of the application or DLL in which the new
  superclass had been defined by a call to RegisterClass.
lpszClassName - The name of the class to be used as balloon help.

All other parameters should be obvious by now.


Description

Refer to the next section for a in-depth description of superclassing. It
is possible to use your own window classes (not "inheriting" from
Golfiery's BalloonHelp class) as "BalloonHelp". Perhaps you want to use
one of your dialogs as a sort of balloon. Contact the author for more
information.
-+++-                      -+++-


Superclassing the balloon help
------------------------------

Golfiery has a special BalloonHelp function for programmers who want to
alter the behaviour of the BalloonHelp window. The demo program BALLOON.EXE
(it's source is BALLOON.C) shows an (IMHO: ugly) example of a superclassed
balloon help. This section describes how superclassing in C works. In C++
you can create your own C++ class wrapper (perhaps by inheriting from TWindow
or CWindow).

For superclassing you first need the instance handle of the Golfiery DLL and
the classname of Golfiery's balloon help window. The classname of Golfiery's
balloon help window is defined in GOLFIERY.H:

#define BALLOONCLASSNAME "Ahii_Balloon"

The instance handle of the Golfiery DLL can be retrieved with the following
code snippet:

  WNDCLASS    wndclass;
  HINSTANCE   hInstGolfiery;

  /*** Get instance handle of the balloon dll ***/
  hInstGolfiery = LoadLibrary("golfiery.dll");
  FreeLibrary(hInstGolfiery);

  /*** Retrieve info about the balloonhelp class ***/
  if ( !GetClassInfo(hInstGolfiery, BALLOONCLASSNAME, &wndclass) )
    return FALSE;

There's one *CATCH* to this approach. This piece of code assumes that Golfiery
is already loaded implicitly by your program (i.e. your program imports
the golfiery functions). If this is not the case (your application loads
golfiery with a LoadLibrary and is importing the Golfiery functions with
calls to the GetProcAddress API), move the FreeLibrary call to the
termination code of your program.

If all's well, wndclass contains the class information of the BalloonHelp
window class. Now we need to clear the CS_GLOBALCLASS bit (if you're
defining the new class inside a DLL, you should let this bit *ON*), store
the old class' procedure and replace the wndclass.lpfnWndProc member
with the address of the superclass procedure, set the instance handle of
the application or DLL that defines the new class, change the background brush
(optional) and assign a new name to the class. Here some code:

  /*** Superclass class won't be global, clear bit ***/
  wndclass.style &= ~CS_GLOBALCLASS;

  /*** New class will be valid for this instance only ***/
  _lpfnOldProc = wndclass.lpfnWndProc;
  wndclass.lpfnWndProc = NewBalloonWndProc;
  wndclass.hInstance = _hInst;
  wndclass.hbrBackground = CreateSolidBrush(RGB(192, 192, 192)) ;
  wndclass.lpszClassName = (LPCSTR)NEWBALLOONCLASSNAME;

Now you can register your superclass with the RegisterClass API function.

The superclass should pass most messages to the old class' procedure.
However there are messages which might be interesting to intercept:

-+++- BLNM_GETTITLEFONT (WM_USER + 1) -+++-

BLNM_GETTITLEFONT               (golfiery.h)

wParam = 0; /* not used */
lParam = 0; /* not used */

Sent during the handling of WM_CREATE and WM_PAINT this message returns
the font for the balloon help title. By default this message returns the
bold faced ANSI variable pitched system font. Your superclass should
intercept this message if it wiil be using another font. You do not have
to call the old class procedure.

The width and height of the new font should be specified in device
coordinates (pixels).
-+++-                                 -+++-

-+++- BLNM_GETTEXTFONT (WM_USER + 3) -+++-

BLNM_GETTEXTFONT                (golfiery.h)

wParam = 0; /* not used */
lParam = 0; /* not used */

Analog to BLNM_GETTITLEFONT. Sent during WM_CREATE and WM_PAINT. Returns
the font for the help text in the balloon. Intercept this message if
you want your superclass to use a different font (the default font is
the ANSI variable pitched system font). If you intercept this message
it's not necessary to call the old class procedure.

The created font must have a width and height specified in device coordinates
(pixels).

NOTE: This message is "mapped" to WM_GETFONT. You can intercept WM_GETFONT
or BLNM_GETTEXTFONT. Intercepting both won't do any harm, but is "overkill".
-+++-                                -+++-

-+++- BLNM_SETBALLOONDIM (WM_USER + 4) -+++-

BLNM_SETBALLOONDIM              (golfiery.h)

wParam = 0; /* not used */
lpbd = (LPBLNDIM)lParam; /* pointer to a BLNDIM struct */

typedef struct {
   int   nX;               /*** position and dimension ***/
   int   nY;
   int   nCx;
   int   nCy;
   int   nTextWidth;       /*** width of text body ***/
   int   nTextHeight;      /*** height of text body ***/
   int   nSeparator;       /*** distance between text and title ***/
   int   nTitleHeight;     /*** height of title ***/
   int   nRRWidth;         /*** Rectangle rounded corners based on used fonts ***/
   int   nRRHeight;
} BLNDIM, FAR* LPBLNDIM, NEAR* NPBLNDIM, * PBLNDIM;

This message is sent *once* and only during the handling of the WM_CREATE
message. After the WM_CREATE code determines the dimensions of the text
it calculates the correct values for each of the members in the BLNDIM
struct. By sending BLNM_SETBALLOONDIM the structure values are stored in an
internal datastructure (allocated in the DLL's local heap). You're allowed
to change the struct's field values before passing the message to the
old procedure class. Remember: the old procedure class *must* be called
*after* you've changed structure members. If you call the old class'
procedure first, the changes won't have any effect.

Keep in mind that Golfiery's balloon help is resolution independent. To
achieve this Golfiery sets the nRRWidth and nRRHeight fields to the character width
and height of the text font. And because the text font and title font are based
on the ANSI variable pitched font (ANSI_VAR_FONT), the standard balloon will
be visible (and readable) on all displays.
-+++-                                  -+++-

-+++- BLNM_GETBALLOONDIM (WM_USER + 5) -+++-

BLNM_GETBALLOONDIM

wParam = 0; /* not used */
lpbd = (LPBLNDIM)lParam; /* pointer to a BLNDIM struct that receives
                            dimension info of a balloon */

This message should *not* be intercepted by the superclass. Also this message
should not be sent to a BalloonHelp window created with one of Golfiery's
BalloonHelp function. At the time a BalloonHelp function returns, the
BalloonHelp window's handle might be invalid.

What's the purpose of this message? Well, it can be send within in your super
class. The lParam is a far pointer to a BLNDIM structure. This structure
will contain the dimension/position values of a balloon.

This message is sent by Golfiery's internal IntBalloonHelp function which
is in its turn is called by all xxxBalloonHelpxxx functions. With this
message the IntBalloonhelp function retrieves the dimension data of a
balloon; the balloon is positioned and sized with a call to the MoveWindow
API function.
-+++-                                  -+++-

-+++- WM_CTLCOLOR (standard Windows message) -+++-

WM_CTLCOLOR

hdc = (HDC)wParam;      /** the dc for the WM_PAINT code **/
hwnd = (HWND)LOWORD(lParam);  /** hwnd of balloon **/
nType = (int)HIWORD(lParam);  /** type of paint action **/

During the handling of the WM_PAINT code, the balloon sends several
WM_CTLCOLOR messages to *itself*. By intercepting these messages you can
control the paint process of the balloon window.

The Balloon window sends three types of WM_CTLCOLOR messages


nType == CTLCOLOR_DLG   (standard Windows type)

if nType is CTLCOLOR_DLG the WM_PAINT code requests the background brush
for the balloon. By default the class procedure returns the class' background
brush (of the wndclass.hbrBackground field). This brush is used for painting
the background of the balloon.


nType == CTLCOLOR_TITLEFONT (50, see golfiery.h)

if nType is CTLCOLOR_TITLEFONT the WM_PAINT code gives the superclass the
chance to alter the attributes of the paint device context (sent through the
wParam). Use this message type to alter the text color, text back mode or
text backcolor of the title text.


nType == CTLCOLOR_TEXTFONT  (CTLCOLOR_TITLEFONT + 1, see golfiery.h)

if nType is CTLCOLOR_TEXTFONT the WM_PAINT code allows the super class to
alter the attributes of the paint device context (sent through the wParam).
Use this message to alter the text color, text back mode or text backcolor
ot the help text.

In all three cases the class procedure returns the background brush.
-+++-                                        -+++-


Known shortcomings
==================

Perhaps there are some shortcomings in this demo version, if you've found one
please let me know


Enhancements
============

March 5/6, 1995 - Special enhancements for the superclassers. The flyby hint
sends WM_CTLCOLOR (CTLCOLOR_DLG) to retrieve the hBrush for the tooltip.

March/April, 1995 - Added real balloonhelp. Fixed word wrapping bug.

Future/planned enhancements:

- icons/bitmaps inside title and text (not within three months, I'm already
busy with another project :-)
- owner drawing
- passing more variables (font handles etc).
- The FlyByHint pause. No it's not a hardcoded value.

(No, I won't write a VBX... Well, perhaps you can persuade me.)


About the author
----------------

Alfons Hoogervorst occasionally contributes to several Fidonet echo areas
(including WINDOWS.PROG, C_ECHO and PASCAL). He has been programming Windows
for about four years. He works as a freelance translator.

He is also the author of "MyStory Not His", a program history utility for
Windows 3.1x. Alfons specializes in low-level Windows programming and
custom controls. He's affluent in languages like C, C++ and Pascal (and a
couple of other languages). Alfons is also a fan of Andrew Schulman (perhaps
someone can send him an autographed "Undocumented Windows"? ;-). Furthermore
he seems to have an obscure obssession for inventing puns for his programming
projects (Golfiery was also known as Ballunatic, MyStory as Maestory).

Currently Alfons works on a special VBX-project nicknamed
"think-thought-thunk".

Alfons can be reached by Fido mail 2:500/121.6252 at The C Programmers
Board (aka DOSBoss West). The C Programmers Board's phone number is
31-020-6124530. 8 databits, no parity, 1 stopbit. Try V42 or V32bis,
connection speed max. 14K4 (in the Netherlands ofcourse).

Fido      2:500/121.6252
Internet  [e-mail]

Alternatively try [e-mail]


Acknowledgments
---------------

Arthur Hoogervorst
Erik Baas (DOSBoss West user)
Rob de Voer
Fabio Cereda Cordiero
Alex Stienstra (sysop of DOSBoss West)

The DOSBoss West users and points for allowing yet another programmer
The WINDOWS.PROG contributers (hey! Don't have any access to WINDOWS.PROG,
don't know why)


About the use of this software
------------------------------

[I found this piece of legal stuff somewhere]

I do not promise that this software works. If you happen to find any bugs,
please let me know. You're allowed to use this software for whatever you want.

Give credits to the person who created this nice piece of software (add my
name to your credits to spiff up your applications :-) In other words,
I *won't* mind my name not appearing in your program's documentation, but
I'd really appreciate it if you add one of the following lines in your
program's copyright notice, documentation or credits:

"Golfiery (c) 1995 by Alfons Hoogervorst"
"Golfiery has been written by Alfons Hoogervorst"


More legal terms:

The author nor any of the above (or in the software) mentioned persons or
companies make NO WARRANTY, either express or implied, regarding the
quality or fitness of this software for a particular purpose. This software
is provided on an "AS IS" basis, it's the user who assumes the entire risk as
to its quality and fitness.

This software is copyright (C) 1995 Alfons Hoogervorst

Permission is hereby granted to use, copy, modify, and distribute this
software (or portions thereof) for any purpose, *without fee*, subject to
these conditions:

1. If any part of the source code for this software is distributed, then this
file must be included, with this copyright and no-warranty notice unaltered;
and any additions, deletions, or *changes* to the original files must be
clearly indicated in accompanying documentation.

2. Permission for use of this software is granted only if the user accepts
full responsibility for any undesirable consequences; the author nor any of
the aforementioned persons or companies can be held responsible or liable for
damages of any kind resulting from incorrect/improper working of the descibed
software.

The author specifically permits and encourages the use of this software in
commercial products, provided that all warranty or liability claims are
assumed by the product vendor.

=============================================================================
Perhaps I mentioned some registered trademarks (not that I know of). In that
case:

Some words or "phrases" in this text file could be/happen to be registered
trademarks of their respective holders.
=============================================================================